﻿/*----------------------------------------------------------------------------------------
*
*  Copyright 2019, Gao Hai Hui, <fromzeropoint@126.com>.  All rights reserved.
*  https://gitee.com/helloworldghh/xoskit.git
*  Use of this source code is governed by a MIT license
*  that can be found in the License file.
*
----------------------------------------------------------------------------------------*/
#ifndef __XOSKIT_XOS_CORE_XOS_STL_SRC_MEM_POOL_MEM_GROUP_H__
#define __XOSKIT_XOS_CORE_XOS_STL_SRC_MEM_POOL_MEM_GROUP_H__

#include <string>
#include "xos_list.h"
#include "xos_map.h"

namespace xos_stl
{

	//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
	// 
	// 基类，一些公用方法
	// 
	template< class T >
	class xos_group_base
	{
	public:
		typedef xos_map< std::string, T >	STR_MAP;
		typedef typename STR_MAP::iterator STR_ITER;

		typedef xos_map< int, T >	INT_MAP;
		typedef typename INT_MAP::iterator INT_ITER;

		typedef xos_list< T > LIST;
		typedef typename LIST::iterator ITER;

	public:
		xos_group_base( xos_common::i_common * pCommon ) : id_gen_ptr( 0 )
		{
			if( pCommon )
			{
				pCommon->create( xos_common::OBJ_ID_GENERATOR, (void **)&id_gen_ptr );
			}
		}
		xos_group_base() : id_gen_ptr( 0 )
		{
		}
		~xos_group_base()
		{
			if( id_gen_ptr )
			{
				id_gen_ptr->release();
				id_gen_ptr = 0;
			}
		}
	protected:
		/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
		// 
		// template funtions
		// 
		template< class INDEX, class MAP >
		T * add_map_item( MAP maps[], INDEX id, T * pT, int num, bool bReplace, int index )
		{
			T * pRemovedT = 0;
			if( ( index >= 0 ) && ( index < num ) )
			{
				MAP & t_map = maps[index];
				typename MAP::ITER i = t_map.find( id );
				bool bSet = true;
				if( i != t_map.end() )
				{
					if( bReplace )
					{
						pRemovedT = i->second;
						t_map.erase( i );
					}
					else
					{
						bSet = false;
					}
				}
				if( bSet )
				{
					t_map[id] = pT;
				}
			}
			return pRemovedT;
		}
		template< class INDEX, class MAP >
		T * get_map_item( MAP maps[], INDEX id, int num, int index )
		{
			T * pT = 0;
			if( ( index >= 0 ) && ( index < num ) )
			{
				MAP & t_map = maps[index];
				typename MAP::ITER i = t_map.find( id );
				if( i != t_map.end() )
				{
					pT = i->second;
				}
			}
			return pT;
		}
		template< class INDEX, class MAP >
		T * remove_map_item( MAP maps[], INDEX id, int num, int index )
		{
			T * pT = 0;
			if( ( index >= 0 ) && ( index < num ) )
			{
				MAP & t_map = maps[index];
				typename MAP::ITER i = t_map.find( id );
				if( i != t_map.end() )
				{
					pT = i->second;
					t_map.erase( i );
				}
			}
			return pT;
		}
    public:
		/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
		// 
		// map, list funtions
		// 
		ITER add_list_item( T * pT )
		{
			t_list.push_back( pT );
			ITER iter = --t_list.end();
			return iter;
		}
		T * remove_list_item( ITER iter )
		{
			T * pT = *iter;
			t_list.erase( iter );
			return pT;
		}
	public:
		/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
		// 
		// object funtions
		// 
		xos_common::i_id_generator * get_id_generator()
		{
			return id_gen_ptr;
		}
		LIST & get_list()
		{
			return t_list;
		}
		/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
		// 
		// mem pool funtions
		// 
		int put_back_to_pool( bool bLock )
		{
			int ret = 0;
			t_list.put_back_to_pool( bLock );
			return ret;
		}
        int clear()
        {
            int ret = 0;
            t_list.clear();
            return ret;
        }
	protected:
		xos_common::i_id_generator * id_gen_ptr;
		LIST t_list;
	};

	//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
	// 
	// 基本版本
	// 
	template< class T, int STR_MAP_NUM, int INT_MAP_NUM >
	class xos_group : public xos_group_base< T >
	{
	public:
		typedef xos_group_base< T > BASE;
	public:
		xos_group( xos_common::i_common * pCommon ) : BASE( pCommon )
		{
		}
		xos_group() : BASE()
		{
		}
		~xos_group()
		{
		}
    public:
		/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
		// 
		// map, list funtions
		// 
		T * add_map_item( const std::string & id, T * pT, int index, bool bReplace = false )
		{
			return BASE::add_map_item( str_map, id, pT, STR_MAP_NUM, bReplace, index );
		}
		T * remove_map_item( const std::string & id, int index )
		{
			return BASE::remove_map_item( str_map, id, STR_MAP_NUM, index );
		}
		T * add_map_item( int id, T * pT, int index, bool bReplace = false )
		{
			return BASE::add_map_item( int_map, id, pT, INT_MAP_NUM, bReplace, index );
		}
		T * remove_map_item( int id, int index )
		{
			return BASE::remove_map_item( int_map, id, INT_MAP_NUM, index );
		}
	public:
		/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
		// 
		// 查询方法
		// 
		T * get_map_item( const std::string & id, int index )
		{
			return BASE::get_map_item( str_map, id, STR_MAP_NUM, index );
		}
		T * get_map_item( int id, int index )
		{
			return BASE::get_map_item( int_map, id, INT_MAP_NUM, index );
		}
		/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
		// 
		// mem pool funtions
		// 
		int put_back_to_pool( bool bLock )
		{
			int ret = 0;
			for( int i = 0; i < STR_MAP_NUM; ++i )
			{
				str_map[i].clear();
			}
			for( int i = 0; i < INT_MAP_NUM; ++i )
			{
				int_map[i].clear();
			}
			BASE::put_back_to_pool( bLock );
			return ret;
		}
        int clear()
        {
            int ret = 0;
            for( int i = 0; i < STR_MAP_NUM; ++i )
            {
                str_map[i].clear();
            }
            for( int i = 0; i < INT_MAP_NUM; ++i )
            {
                int_map[i].clear();
            }
            BASE::clear();
            return ret;
        }
	protected:
		typename BASE::STR_MAP str_map[STR_MAP_NUM];
		typename BASE::INT_MAP int_map[INT_MAP_NUM];
	};

	//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
	// 
	// STR_MAP_NUM = 0的特化版本
	// 
	template< class T, int INT_MAP_NUM >
	class xos_group< T, 0, INT_MAP_NUM > : public xos_group_base< T >
	{
	public:
		typedef xos_group_base< T > BASE;
	public:
		xos_group( xos_common::i_common * pCommon ) : BASE( pCommon )
		{
		}
		xos_group() : BASE()
		{
		}
		~xos_group()
		{
		}
    public:
		/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
		// 
		// map, list funtions
		// 
		T * add_map_item( int id, T * pT, int index, bool bReplace = false )
		{
			return BASE::add_map_item( int_map, id, pT, INT_MAP_NUM, bReplace, index );
		}
		T * remove_map_item( int id, int index )
		{
			return BASE::remove_map_item( int_map, id, INT_MAP_NUM, index );
		}
	public:
		/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
		// 
		// 查询方法
		// 
		T * get_map_item( int id, int index )
		{
			return BASE::get_map_item( int_map, id, INT_MAP_NUM, index );
		}
		/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
		// 
		// mem pool funtions
		// 
		int put_back_to_pool( bool bLock )
		{
			int ret = 0;
			for( int i = 0; i < INT_MAP_NUM; ++i )
			{
				int_map[i].clear();
			}
			BASE::put_back_to_pool( bLock );
			return ret;
		}
        int clear()
        {
            int ret = 0;
            for( int i = 0; i < INT_MAP_NUM; ++i )
            {
                int_map[i].clear();
            }
            BASE::clear();
            return ret;
        }
	protected:
		typename BASE::INT_MAP int_map[INT_MAP_NUM];
	};

	//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
	// 
	// INT_MAP_NUM = 0的特化版本
	// 
	template< class T, int STR_MAP_NUM >
	class xos_group< T, STR_MAP_NUM, 0 > : public xos_group_base< T >
	{
	public:
		typedef xos_group_base< T > BASE;
	public:
		xos_group( xos_common::i_common * pCommon ) : BASE( pCommon )
		{
		}
		xos_group() : BASE()
		{
		}
		~xos_group()
		{
		}
    public:
		/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
		// 
		// map, list funtions
		// 
		T * add_map_item( const std::string & id, T * pT, int index, bool bReplace = false )
		{
			return BASE::add_map_item( str_map, id, pT, STR_MAP_NUM, bReplace, index );
		}
		T * remove_map_item( const std::string & id, int index )
		{
			return BASE::remove_map_item( str_map, id, STR_MAP_NUM, index );
		}
	public:
		/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
		// 
		// 查询方法
		// 
		T * get_map_item( const std::string & id, int index )
		{
			return BASE::get_map_item( str_map, id, STR_MAP_NUM, index );
		}
		/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
		// 
		// mem pool funtions
		// 
		int put_back_to_pool( bool bLock )
		{
			int ret = 0;
			for( int i = 0; i < STR_MAP_NUM; ++i )
			{
				str_map[i].clear();
			}
			BASE::put_back_to_pool( bLock );
			return ret;
		}
        int clear()
        {
            int ret = 0;
            for( int i = 0; i < STR_MAP_NUM; ++i )
            {
                str_map[i].clear();
            }
            BASE::clear();
            return ret;
        }
	protected:
		typename BASE::STR_MAP str_map[STR_MAP_NUM];
	};

	//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
	// 
	// STR_MAP_NUM = 0，INT_MAP_NUM = 0的特化版本，退化成一个list
	// 
	template< class T >
	class xos_group< T, 0, 0 > : public xos_group_base< T >
	{
	public:
		typedef xos_group_base< T > BASE;
	public:
		xos_group( xos_common::i_common * pCommon ) : BASE( pCommon )
		{
		}
		xos_group() : BASE()
		{
		}
		~xos_group()
		{
		}
	};

} // xos_stl

#endif // __XOSKIT_XOS_CORE_XOS_STL_SRC_MEM_POOL_MEM_GROUP_H__
